home *** CD-ROM | disk | FTP | other *** search
/ TPUG - Toronto PET Users Group / TPUG Users Group CD / TPUG Users Group CD.iso / AMIGA / AMICUS / AMICUS26.ADF / SoundScape / LatticeExamples / tx.c < prev    next >
C/C++ Source or Header  |  1989-01-26  |  13KB  |  461 lines
  1. /*      TX.C
  2.  
  3.         (c) 1987 Todor Fay 
  4.  
  5. */ 
  6.  
  7. #include "exec/types.h" 
  8. #include "exec/exec.h" 
  9. #include "hardware/custom.h" 
  10. #include "hardware/cia.h" 
  11. #include "exec/interrupts.h" 
  12. #include "exec/memory.h" 
  13. #include "hardware/intbits.h" 
  14. #include "libraries/dos.h" 
  15. #include "intuition/intuition.h"
  16. #include "soundscape.h" 
  17.  
  18. extern struct CIA ciaa;
  19. extern struct Custom custom;
  20.  
  21. /*    The state structure for this module has just the
  22.       file name for saving a TX81Z (or DX21/27/100) voice.  
  23.       Whenever an environment save command (SAVESTATE) 
  24.       occurs, the file that the voice was saved in is 
  25.       returned here.  When an environment load command 
  26.       (LOADSTATE) happens, the file that is given here 
  27.       will be loaded by this module.
  28. */
  29.  
  30. struct SynthState { 
  31.     long length; 
  32.     char filename[70]; 
  33. }; 
  34.  
  35. /*    Initialise the file name as empty. */
  36.  
  37. static struct SynthState synthstate = { 70,0, }; 
  38.  
  39. /*    The port id for this port. */
  40.  
  41. static short thisport;
  42.  
  43. /*    The icon in the Patch Panel. */
  44.  
  45. UWORD tx81zdata[] = {        /* 32 x 12 */ 
  46. 0,        0,        
  47. 0,        0,        
  48. 0,        0,        
  49. 0,        0,        
  50. 0,        0,        
  51. 0,        0,        
  52. 0,        0,        
  53. 8078,     32752,        
  54. 12486,    448,        
  55. 8070,     1792,        
  56. 12486,    7168,        
  57. 8079,     32752,        
  58. 16383,    57344,        
  59. 224,      0,        
  60. 231,      28672,        
  61. 227,      57344,        
  62. 225,      49152,        
  63. 227,      57344,        
  64. 231,      28672,        
  65. 0,        32752,        
  66. 0,        448,        
  67. 0,        1792,        
  68. 0,        7168,        
  69. 0,        32752,        
  70. };
  71.  
  72. struct Image tx81zimage = { 0,0,32,12,2,tx81zdata,3,0,0 };
  73.  
  74. /*    We need to be able to display messages to the user.
  75.       For example, "Sending the voice...".  Two
  76.       routines handle this.  Onmessage opens a window
  77.       and displays the given strings.  Offmessage
  78.       closes that window.  Here is the window declaration.
  79. */
  80.  
  81. struct NewWindow NewWindowStructure = {
  82.         134,35,
  83.         336,66,
  84.         0,1,
  85.         NULL,
  86.         ACTIVATE,
  87.         NULL,
  88.         NULL,
  89.         "TX81Z/DX21/DX27/DX100 Librarian",
  90.         NULL,
  91.         NULL,
  92.         5,5,
  93.         640,200,
  94.         WBENCHSCREEN
  95. };
  96.  
  97. struct Window *messagewindow = 0;
  98.  
  99. void onmessage(string1,string2) 
  100.  
  101. /*      Opens a window and prints the message.   
  102.         Window is closed by offmessage(). 
  103. */ 
  104.  
  105. char string1[], string2[];
  106.  
  107. { 
  108.     static struct IntuiText text = { 2,0,JAM2,0,0,0,0, };
  109.     messagewindow = (struct Window *) 
  110.         OpenWindow(&NewWindowStructure);
  111.     if (messagewindow) {
  112.         text.IText = string1; 
  113.         PrintIText(messagewindow->RPort,&text,20,20);
  114.         if (string2) {
  115.             text.IText = string2; 
  116.             PrintIText(messagewindow->RPort,&text,20,30); 
  117.         }
  118.     }
  119. } 
  120.  
  121. void offmessage() 
  122.  
  123. /*      This just closes messagewindow if it is open. */
  124.  
  125. { 
  126.     if (messagewindow) {
  127.         CloseWindow(messagewindow); 
  128.     }
  129.     messagewindow = 0; 
  130. }   
  131.   
  132.  
  133. opencode(direction) 
  134.  
  135. /*      Routine to open this modules's port in the
  136.         direction specified. Always return TRUE
  137.         for success.
  138. */        
  139.  
  140. char direction; 
  141.  
  142. { 
  143.     return(1); 
  144. } 
  145.  
  146.  
  147. closecode(direction)
  148.  
  149. /*      Always close successfully. */
  150.  
  151. char direction; 
  152.  
  153. { 
  154.     return(1); 
  155. } 
  156.  
  157.  
  158. unsigned long processbyte(buffer,maxlength,midiindata) 
  159.  
  160. /*      When a data byte comes in, this routine is
  161.         called to process it.  Buffer is a pointer
  162.         to an array to store the data in.  Maxlength
  163.         is the size of that array.  Midiindata is
  164.         the data byte that just came in.
  165.         
  166.         The static variable sysexon keeps track of
  167.         whether we are currently reading a system
  168.         exclusive packet.  It is initialised to
  169.         FALSE (0). When a System Exclusive status
  170.         byte comes in, sysexon is set.  When the
  171.         end of the packet is reached, sysexon is
  172.         turned off again.
  173.  
  174.         The static variable length keeps track of 
  175.         where we are in the array.  It is not 
  176.         allowed to become greater than maxlength.
  177.  
  178.         Return 0 if still reading or about to
  179.         read the packet.  Return the length when
  180.         the packet end has been reached.
  181. */
  182.  
  183. register unsigned char *buffer;
  184. register unsigned long maxlength;
  185. register unsigned char midiindata; 
  186.  
  187. { 
  188.     static unsigned long length;
  189.     static char sysexon = 0; 
  190.           /*  Is this a status byte? */
  191.     if (midiindata & 0x80) { 
  192.           /*  MIDI real time event? */
  193.         if (midiindata >= CLOCK) { 
  194.             return(0); 
  195.         } 
  196.           /* End of packet? */
  197.         else if (sysexon) { 
  198.             sysexon = 0; 
  199.             buffer[length++] = midiindata;
  200.             return(length);
  201.         } 
  202.           /* Start of packet? */
  203.         else if (midiindata == SYSTEMX) { 
  204.             sysexon = 1;
  205.             length = 1;
  206.             *buffer = SYSTEMX;
  207.         } 
  208.     } 
  209.           /* Read data. */
  210.     else if (sysexon) { 
  211.         if (length < maxlength) { 
  212.             buffer[length++] = midiindata; 
  213.         }
  214.     } 
  215.     return(0); 
  216. } 
  217.  
  218.  
  219. unsigned long ReceiveSysEx(buffer,maxlength) 
  220.  
  221. /*      To receive a system exclusive buffer,
  222.         disable interrupts and poll the serial
  223.         port and mouse button.  Whenever a data
  224.         byte comes in, pass it to the processbyte
  225.         routine, which deals with is appropriately.
  226.         Once the packet is in, return the length.
  227. */
  228.  
  229. register char *buffer; 
  230. register unsigned long maxlength; 
  231.  
  232. { 
  233.     register unsigned char c; 
  234.     unsigned long length = 0;
  235.     Disable(); 
  236.     for (;;) { 
  237.         while (!(custom.serdatr & 0x4000)) {
  238.             if ((~ciaa.ciapra) & 0xC0) {
  239.                 Enable();
  240.                 return(0);
  241.             }
  242.         }
  243.         c = (unsigned char) custom.serdatr; 
  244.         custom.intreq = INTF_RBF;
  245.         if (length = processbyte(buffer,maxlength,c)) 
  246.             break; 
  247.     } 
  248.     Enable(); 
  249.     return(length); 
  250. } 
  251.  
  252.  
  253. void SendSysEx(buffer,length) 
  254.  
  255. /*      First, set the priority of this task to 
  256.         higher than the SoundScape packet router
  257.         so there is no danger of SoundScape sending
  258.         a MIDI packet at the same time.
  259.         
  260.         Then, send all the bytes in the buffer,
  261.         polling the buffer empty bit before 
  262.         sending each byte.
  263.  
  264.         When done, bring the priority back down.
  265. */
  266.  
  267. register char *buffer; 
  268. register unsigned long length;
  269.  
  270. { 
  271.     register long oldpri = SetTaskPri(FindTask(0),21); 
  272.     register unsigned long i; 
  273.     for (i=0; i<length; i++) { 
  274.         while (!(custom.serdatr & 0x2000)); 
  275.         custom.serdat = buffer[i] | 0x300; 
  276.     } 
  277.     SetTaskPri(FindTask(0),oldpri); 
  278. } 
  279.           
  280.  
  281. void dosomething(direction,filename) 
  282.  
  283. /*      This routine is called to either read
  284.         a voice from disk and send it
  285.         to the synth, or read a voice from
  286.         the synth and store it to disk.
  287.         
  288.         Direction is set if we are to
  289.         store a sound to disk, otherwise cleared.
  290.  
  291.         A filename may be given (the case for
  292.         environment loads and saves.) If
  293.         so, the variable filename will have
  294.         that file name in it.  If there is
  295.         no filename (filename[0] == 0), 
  296.         put up a requester with a call to
  297.         ReadFileName or WriteFileName.
  298.  
  299.         If saving a voice to disk, first
  300.         send a dump request to the synth.
  301.         Then read the system exclusive packet
  302.         that comes back.  There is a danger
  303.         that no synth is hooked up, or the
  304.         wrong data is returned.  If this happens,
  305.         the length of the data returned will not
  306.         be 101, so don't save it to file.
  307.  
  308.         If sending a new voice, just read
  309.         it from file and send the data.
  310. */
  311.  
  312. char direction;
  313. register char filename[]; 
  314.  
  315. { 
  316.     register long buffer; 
  317.     register long file; 
  318.     static unsigned char dumprequest[] = { 0xF0,0x43,0x20,0x03,0xF7};
  319.     long length; 
  320.     buffer = AllocMem(200,MEMF_PUBLIC); 
  321.     if (buffer) { 
  322.         if (direction) { 
  323.             if (!filename[0]) 
  324.                 WriteFileName(filename,"TX81Z/DX Voice","tx81zvoice"); 
  325.             if (filename[0]) { 
  326.                 onmessage("Getting a Voice... ",
  327.                     "Click mouse to abort");
  328.                 SendSysEx(dumprequest,5);
  329.                 length = ReceiveSysEx(buffer,200);
  330.                 offmessage(); 
  331.                 if (length == 101) {
  332.                     file = Open(filename,MODE_NEWFILE); 
  333.                     if (file) { 
  334.                         Write(file,&length,4); 
  335.                         Write(file,buffer,length); 
  336.                         Close(file); 
  337.                     }
  338.                 } 
  339.             } 
  340.         } 
  341.         else { 
  342.             if (!filename[0]) 
  343.                 ReadFileName(filename,"TX81Z/DX Voice","tx81zvoice");
  344.             if (filename[0]) { 
  345.                 file = Open(filename,MODE_OLDFILE); 
  346.                 if (file) { 
  347.                     Read(file,&length,4);
  348.                     if (length == 101) { 
  349.                         Read(file,buffer,length); 
  350.                         Close(file); 
  351.                         onmessage("Sending the Voice... ",0);
  352.                         SendSysEx(buffer,length); 
  353.                         offmessage(); 
  354.                     }
  355.                 } 
  356.             } 
  357.         } 
  358.         FreeMem(buffer,200); 
  359.     } 
  360. } 
  361.  
  362.   
  363. void editcode(direction,command,buffer) 
  364.  
  365. /*      This, the edit routine, is called under
  366.         five circumstances:
  367.  
  368.         USEREDIT:
  369.         The user clicked on either the left or right
  370.         icon in the patch panel.  Which icon is
  371.         determined by the variable direction.  Clear
  372.         the SynthState filename field so there is no
  373.         current filename and make a FunctionCall to 
  374.         dosomething(direction,synthstate.filename)
  375.         which will either load a sound or save
  376.         one.
  377.  
  378.         SETSTATE:
  379.         This occurs when another module wishes to
  380.         change the data in this module's state
  381.         structure.  Simply copy the passed buffer
  382.         into synthstate.
  383.  
  384.         GETSTATE:
  385.         Another module wishes to read the contents
  386.         of this module's state structure.  Simply
  387.         copy synthstate into the passed buffer.
  388.  
  389.         LOADSTATE:
  390.         Another module asks this module to load
  391.         files.  This ususally occurs in the
  392.         context of an environment load.  Once again,
  393.         a buffer is passed and the data from it
  394.         is copied into synthstate.  This should have the
  395.         name of the file to read and send to the
  396.         TX81Z.
  397.  
  398.         SAVESTATE:
  399.         Another module asks this module to save
  400.         files.  This usually occurs in the
  401.         context of an environment save. This
  402.         time, we get the sound from the TX81Z and
  403.         save it to disk, then return the file name,
  404.         so that can be stored in the environment 
  405.         file.
  406. */ 
  407.  
  408. char direction, command; 
  409. struct SynthState *buffer; 
  410.  
  411. { 
  412.     switch (command) { 
  413.         case USEREDIT : 
  414.             synthstate.filename[0] = 0; 
  415.             FunctionCall(dosomething,direction,synthstate.filename); 
  416.             break; 
  417.         case SETSTATE : 
  418.             movmem(buffer,&synthstate,sizeof(synthstate)); 
  419.             break; 
  420.         case GETSTATE : 
  421.             movmem(&synthstate,buffer,sizeof(synthstate)); 
  422.             break; 
  423.         case LOADSTATE : 
  424.             movmem(buffer,&synthstate,sizeof(synthstate)); 
  425.             FunctionCall(dosomething,0,synthstate.filename); 
  426.             movmem(&synthstate,buffer,sizeof(synthstate)); 
  427.             break; 
  428.         case SAVESTATE : 
  429.             FunctionCall(dosomething,1,synthstate.filename); 
  430.             movmem(&synthstate,buffer,sizeof(synthstate)); 
  431.             break; 
  432.     } 
  433.     buffer->length = 70; 
  434. } 
  435.   
  436. long SoundScapeBase, IntuitionBase, GfxBase;
  437.  
  438. /*      Here's the main program.  As always with a 
  439.         SoundScape module, open the SoundScape library
  440.         to get a handle on the routines, then close
  441.         it so it can be eventually closed by the 
  442.         program that opened it initially.
  443.         Create a midi port in the patch panel and
  444.         wait for it to be closed, then leave.
  445. */
  446.  
  447. void main() { 
  448.     IntuitionBase = OpenLibrary("intuition.library",0); 
  449.     GfxBase = OpenLibrary("graphics.library",0); 
  450.     SoundScapeBase = OpenLibrary("soundscape.library",0); 
  451.     if (SoundScapeBase) { 
  452.         CloseLibrary(SoundScapeBase); 
  453.         thisport = AddMidiPort(opencode,closecode,editcode,0, 
  454.             &tx81zimage,&tx81zimage,-1,"tx81z"); 
  455.         SetTaskPri(FindTask(0),-20); 
  456.         while (MidiPort(thisport)) Delay(100); 
  457.     } 
  458.     CloseLibrary(IntuitionBase); 
  459.     CloseLibrary(GfxBase); 
  460. }
  461.